home *** CD-ROM | disk | FTP | other *** search
/ Meeting Pearls 1 / Meeting Pearls Vol 1 (1994).iso / installed_progs / text / faqs / func-lang-faq < prev    next >
Encoding:
Internet Message Format  |  1994-05-17  |  36.1 KB
  1. Subject: comp.lang.functional Frequently Asked Questions (monthly posting)
  2. Newsgroups: comp.lang.functional,comp.answers,news.answers
  3. From: jones-mark@CS.YALE.EDU (Mark P. Jones)
  4. Date: 15 May 1994 18:22:26 GMT
  5.  
  6.  
  7. Archive-name: func-lang-faq
  8. Last-modified: April 15, 1994
  9.  
  10. ---------------------------------------------------------------------------
  11.              A Frequently Asked Questions list (FAQ) for
  12.                       comp.lang.functional
  13. ---------------------------------------------------------------------------
  14. A copy of this FAQ is available by anonymous ftp from nebula.cs.yale.edu in
  15. the file pub/comp.lang.functional/FAQ.
  16. ---------------------------------------------------------------------------
  17. New this month:
  18.  - Added a pointer to Mark Leone's collection of online resources for
  19.    programming language research on the World-Wide Web.
  20.  
  21. ---------------------------------------------------------------------------
  22. TABLE OF CONTENTS:
  23.  
  24. 1) GENERAL QUESTIONS
  25.    1.1) What is a functional language?
  26.    1.2) Where can I find out more about the history and motivation
  27.         for functional programming?
  28.    1.3) Are there any books about functional programming?
  29.    1.4) Where is a good place to look for information about current
  30.         research in functional languages?
  31.    1.5) What other newsgroups might be of interest to readers of
  32.         comp.lang.functional?
  33.    1.6) Is comp.lang.functional archived anywhere?
  34.  
  35. 2) FREQUENT TOPICS OF DISCUSSION:
  36.    2.1) What is a monad?
  37.    2.2) How can I write a parser in a functional language?
  38.    2.3) What does it mean to say that a language is strict/non-strict?
  39.    2.4) What about the performance of functional programs?
  40.    2.5) What is a purely functional language?
  41.    2.6) Other subjects:
  42.  
  43. 3) LANGUAGE IMPLEMENTATIONS:
  44.    ASpecT, Caml Light, Clean, Erlang, FP, Gofer, Haskell, Hope, Id, IFP,
  45.    J, Miranda(TM), ML, NESL, OPAL, Scheme and Sisal.
  46.  
  47. 4) OTHER RESOURCES:
  48.    4.1) Bibliographies:
  49.    4.2) Translators:
  50.    4.3) Online services:
  51.  
  52. 5) CREDITS AND DISCLAIMERS:
  53.  
  54. ---------------------------------------------------------------------------
  55. 1) GENERAL QUESTIONS:
  56.  
  57. Comp.lang.functional is an unmoderated usenet newsgroup for the
  58. discussion of functional programming languages, including their
  59. design, application, theoretical foundation and implementation.
  60.  
  61. ---------
  62. 1.1) What is a functional language?
  63.  
  64. Opinions differ, even within the functional programming community,
  65. on the precise definition of ``functional programming languages''.
  66. Here is a definition that, broadly speaking, represents the kind of
  67. languages that are discussed in this newsgroup:
  68.  
  69.   Functional programming is a style of programming that emphasizes
  70.   the evaluation of expressions, rather than execution of commands.
  71.   The expressions in these language are formed by using functions to
  72.   combine basic values.
  73.  
  74.   A functional language is a language that supports and encourages
  75.   programming in a functional style.
  76.  
  77.   For example, consider the task of calculating the sum of the
  78.   integers from 1 to 10.  In an imperative language, this might be
  79.   expressed using a loop, repeatedly updating the values held in
  80.   counter and accumulator variables:
  81.  
  82.        total = 0;
  83.        for (i=1; i<=10; ++i)
  84.            total += i;
  85.  
  86.   In a functional language, the same program would be expressed
  87.   without any variable updates.  For example, in Haskell or Miranda,
  88.   the required sum can be calculated by evaluating the expression:
  89.  
  90.        sum [1..10].
  91.  
  92.   Here, [1..10] is an expression that represents the list of integers
  93.   from 1 to 10, while sum is a function that can be used to calculate
  94.   the sum of an arbitrary list of values.
  95.  
  96.   The same idea could also be used in strict languages like ML or
  97.   Scheme, but it is more common to find such programs written with
  98.   an explicit loop, often expressed as a form of recursion.
  99.   Nevertheless, there is still no need to update the values of the
  100.   variables involved.
  101.  
  102.   SML:    let fun sum i tot = if i=0 then tot else sum (i-1) (tot+i)
  103.           in sum 10 0
  104.           end
  105.  
  106.   Scheme: (define sum
  107.              (lambda (from total)
  108.                  (if (= 0 from)
  109.                      total
  110.                      (sum (- from 1) (+ total from)))))
  111.           (sum 10 0)
  112.  
  113.   Of course, it is often possible to write programs in an imperative
  114.   language using a functional style, and vice versa.  It is then
  115.   a matter of opinion whether a particular language can be described
  116.   as functional or not.
  117.  
  118.  
  119. ---------
  120. 1.2) Where can I find out more about the history and motivation
  121. for functional programming?
  122.  
  123. Here are a couple of references that should help:
  124.  
  125.   "Conception, Evolution, and Application of Functional Programming
  126.   Languages", Paul Hudak, ACM Computing Surveys, Volume 21, Number 3,
  127.   pp.359--411, 1989.
  128.  
  129.   "Why functional programming matters", John Hughes, The Computer
  130.   Journal, Volume 32, Number 2, April 1989.
  131.  
  132.  
  133. ---------
  134. 1.3) Are there any books about functional programming?
  135.  
  136. Yes, there are quite a few.  For details about programming in a
  137. functional language:
  138.  
  139.   o  "Introduction to functional programming", Richard Bird and
  140.      Philip Wadler, Prentice Hall, 1988.  ISBN 0-13-484189-1.
  141.  
  142.   o  "ML for the working programmer", L.C. Paulson, Cambridge
  143.      University Press, 1991.  ISBN 0-521-39022-2.
  144.  
  145. And for those with an interest in implementation:
  146.  
  147.   o  "The implementation of functional programming languages",
  148.      Simon Peyton Jones, Prentice Hall, 1987.  ISBN 0-13-453333-X.
  149.  
  150.   o  "Compiling with continuations", Andrew Appel, Cambridge
  151.      University Press, 1992.  ISBN 0-521-41695-7.
  152.  
  153. For brevity, I've restricted myself to two books in each of the
  154. above categories, one concerned with non-strict languages, the
  155. other with strict languages.  There are several other good books
  156. in each category.
  157.  
  158. The following article may also be of interest to those looking for
  159. books about functional programming:
  160.  
  161.   o  Simon Thompson, Comparative review of functional programming
  162.      textbooks (Bailey, Bird and Wadler, Holyer, Paulson, Reade,
  163.      Sokoloski, Wikstrom), Computing Reviews, May 1992 (CR number
  164.      9205-0262).
  165.  
  166.  
  167. ---------
  168. 1.4) Where is a good place to look for information about current
  169.      research in functional languages?
  170.  
  171. Here are some good places to start:
  172.  
  173. Journals:
  174.   o  The Journal of Functional Programming, published by CUP.
  175.   o  Lisp and Symbolic Computation, published by Kluwer.
  176.  
  177. Conference proceedings:
  178.   o  Lisp and Functional programming (LFP).
  179.   o  Functional Programming Languages and Computer Architecture (FPCA).
  180.   o  Principles of Programming Languages (POPL).
  181.   o  European Symposium on Programming (ESOP).
  182.  
  183.   (Most of these are published by the ACM press, or in the Springer
  184.   Verlag Lecture Notes in Computer Science Series).
  185.  
  186.  
  187. ---------
  188. 1.5) What other newsgroups might be of interest to readers of
  189. comp.lang.functional?
  190.  
  191. There are several newsgroups dealing with related languages and
  192. ideas, including:
  193.  
  194.     comp.lang.ml    for discussion related to ML
  195.     comp.lang.scheme    for discussion about Scheme
  196.     comp.lang.lisp    for discussion about Lisp
  197.     comp.lang.apl    for discussion about APL, J, etc.
  198.  
  199.  
  200. ---------
  201. 1.6) Is comp.lang.functional archived anywhere?
  202.  
  203. No, as far as I know, there is no public archive of comp.lang.functional
  204. (but, of course, many readers keep copies of old articles for their
  205. personal use).  The possibility of establishing a public archive
  206. has been raised a number of times in the past but have not been
  207. pursued due to an apparent lack of interest, and concerns that
  208. archiving might discourage novices from posting articles.
  209.  
  210.  
  211. ---------------------------------------------------------------------------
  212. 2) FREQUENT TOPICS OF DISCUSSION:
  213.  
  214. 2.1) What is a monad?
  215. ---------------------
  216. The concept of a monad comes from category theory; I'll spare you
  217. the full details since you can find these in standard text books
  218. on the subject.  Much of the recent interest in monads in functional
  219. programming is the result of recent papers that show how monads
  220. can be used to describe all kinds of different programming language
  221. features -- for example, I/O, manipulation of state, continuations
  222. and exceptions -- in purely functional languages like Haskell.
  223.  
  224.   o  Philip Wadler, Comprehending Monads (from the ACM conference
  225.      on LISP & Functional Programming, Nice, France, 1990).
  226.  
  227.   o  Philip Wadler, The Essence of Functional Programming (from ACM
  228.      Principles of Programming Languages 1992).
  229.  
  230.   o  Simon Peyton Jones and Philip Wadler, Imperative Functional
  231.      Programming (from ACM Principles of Programming Languages 1993).
  232.  
  233. These papers are essential reading for anyone interested in the
  234. use of monads for functional programming.  Copies of these papers
  235. are currently available by anonymous ftp from ftp.dcs.glasgow.ac.uk
  236. in the subdirectory pub/glasgow-fp/papers.
  237.  
  238.  
  239. 2.2) How can I write a parser in a functional language?
  240. -------------------------------------------------------
  241. A parser is a program that converts a list of input tokens, usually
  242. characters, into a value of the appropriate type.  A simple example
  243. might be a function to find the integer value represented by a
  244. string of digits.  A more complex example might be to translate
  245. programs written in a particular concrete syntax into a suitable
  246. abstract syntax as the first stage in the implementation of a
  247. compiler or interpreter.  There are two common ways to write a
  248. parser in a functional language:
  249.  
  250.   o  Using a parser generator tool.  Some functional language
  251.      implementations support tools that generate a parser automatically
  252.      from a specification of the grammar (in much the same way that
  253.      a C programmer uses yacc).  Different tools are available,
  254.      depending on the language and implementation used.
  255.  
  256.   o  Using combinator parsing.  Parsers are represented by functions
  257.      and combined with a small set of combinators, leading to
  258.      parsers that closely resemble the grammar of the language
  259.      being read.  Parsers written in this way can use backtracking.
  260.      The techniques of combinator parsing have been known for quite
  261.      some time.  Two comparatively recent papers on the subject are:
  262.  
  263.        -  "How to Replace Failure with a List of Successes",
  264.           Philip Wadler, FPCA '85, Springer Verlag LNCS 201, 1985.
  265.  
  266.        -  "Higher-order functions for parsing", Graham Hutton,
  267.       Journal of Functional Programming, 2, 3, July 1992.
  268.  
  269.      The latter paper is also available by anonymous ftp from
  270.      ftp.cs.chalmers.se in the file pub/cs-reports/papers/parsing.dvi
  271.      and includes some references to other related papers.
  272.  
  273.  
  274. 2.3) What does it mean to say that a language is strict/non-strict?
  275. --------------------------------------------------------------------
  276. Here's one (operational) way to explain the difference:
  277.  
  278. In a strict language, the arguments to a function are always
  279. evaluated before it is invoked.  As a result, if the evaluation of
  280. an expression exp does not terminate properly (for example, because
  281. it generates a run-time error or enters an infinite loop), then
  282. neither will an expression of the form  f(exp).  ML and Scheme are
  283. both examples of this.
  284.  
  285. In a non-strict language, the arguments to a function are not
  286. evaluated until their values are actually required.  For example,
  287. evaluating an expression of the form f(exp) may still terminate
  288. properly, even if evaluation of exp would not, if the value of
  289. the parameter is not used in the body of f.  Miranda and Haskell
  290. are examples of this approach.
  291.  
  292. It is possible to support a mixture of these two approaches; some
  293. versions of Hope do this.
  294.  
  295.  
  296. 2.4) What about the performance of functional programs?
  297. -------------------------------------------------------
  298. In some circles, programs written in functional languages, have
  299. obtained a reputation for lack of performance.  Part of this results
  300. from the high-level of abstraction that is common in such programs
  301. and from powerful features like higher-order functions, automatic
  302. storage management, etc.  Of course, the performance of functional
  303. languages keeps improving with new developments in compiler
  304. technology.
  305.  
  306. The paper below compares five current implementations of lazy
  307. functional languages:
  308.  
  309.   ``Benchmarking implementations of lazy functional languages''
  310.   P. H. Hartel and K. G. Langendoen FPCA 93, ACM, pp 341-349
  311.   (By ftp: ftp.fwi.uva.nl, directory pub/functional).
  312.  
  313. Experiments with a heavily optimising compiler for Sisal, a strict
  314. functional language, show that functional programs can be faster
  315. than Fortran:
  316.  
  317.   ``Retire FORTRAN? A debate rekindled''
  318.   D. C. Cann, CACM, 35(8), pp. 81-89, Aug. 1992
  319.  
  320.  
  321. 2.5) What is a purely functional language?
  322. ------------------------------------------
  323. This question has been the subject of some debate in recent messages
  324. posted to comp.lang.functional.  It is widely agreed that languages
  325. like Haskell and Miranda are `purely functional', while SML and
  326. Scheme are not.  However, there are some small differences of
  327. opinion about the precise technical motivation for this distinction.
  328. One definition that has been suggested is as follows:
  329.  
  330.   The term `purely functional language' is often used to describe
  331.   languages which perform all their computations via function
  332.   application.  This is in contrast to languages, like Scheme and
  333.   Standard ML, which are predominantly functional but also allow
  334.   `side effects' (computational effects caused by expression
  335.   evaluation which persist after the evaluation is completed).
  336.  
  337.   Sometimes, the term `purely functional' is also used in a broader
  338.   sense to mean languages which might incorporate computational
  339.   effects, but without altering the notion of `function' (as
  340.   evidenced by the fact that the essential properties of functions
  341.   are preserved.)  Typically, the evaluation of an expression can
  342.   yield a `task' which is then executed separately to cause
  343.   computational effects.  The evaluation and execution phases are
  344.   separated in such a way that the evaluation phase does not
  345.   compromise the standard properties of expressions and functions.
  346.   The input/output mechanisms of Haskell, for example, are of this
  347.   kind.
  348.  
  349.  
  350. 2.6) Other subjects:
  351. --------------------
  352. There probably ought to be something here about programming with
  353. GUIs (Fudgets, eXene, etc.), Input/Output, General Foundations
  354. (basics of lambda calculus, perhaps?), and parallelism.  Anybody
  355. want to write some brief comments addressing one/some of these?
  356. (Some sections are already in preparation.)
  357.  
  358.  
  359. ---------------------------------------------------------------------------
  360. 3) LANGUAGE IMPLEMENTATIONS:
  361.  
  362. ASpecT:        ASpecT is a strict functional language, developed at
  363.         the University of Bremen, originally intended as
  364.         an attempt to provide an implementation for (a
  365.         subset of) Algebraic Specifications of Abstract
  366.         Datatypes.  The system was designed to be as
  367.         user-friendly as possible, including overloading
  368.         facilities and a source-level debugger.  Efficiency
  369.         called for call-by-value evaluation and reference
  370.         counting memory management.
  371.  
  372.         Over the years more and more features were added,
  373.         including subsorting, functionals and restricted
  374.         polymorphism. The ASpecT compiler translates the
  375.         functional source code to C, resulting in fast and
  376.         efficient binaries.
  377.  
  378.         The most important application of ASpecT to date
  379.         is the interactive graph visualization system
  380.         daVinci; currently (Oct '93), version 1.2 is composed
  381.         of 23.000 lines of code. For more information please
  382.         contact the project daVinci by e-mail:
  383.         daVinci@Informatik.Uni-Bremen.DE
  384.  
  385.         ASpecT is available by anonymous FTP from
  386.         wowbagger.PC-Labor.Uni-Bremen.DE in the directory
  387.         /pub/lang/ASpecT. ASpecT has been ported to many
  388.         platforms like Sun3, Sun4, Dec VAX, IBM RS6000,
  389.         NeXT, Apple A/UX, PC (OS/2, Linux), Amiga and Atari
  390.         ST/TT.
  391.  
  392.  
  393. Caml Light:     Caml Light is an implementation of the ML language
  394.         that does not comply to the Standard, but is
  395.         distinguished by its small size, modest memory
  396.         requirements, availability on microcomputers, simple
  397.         separate compilation, interface with C, and portable
  398.         graphics functions.
  399.  
  400.         Caml Light 0.6 runs on most Unix machines, on the
  401.         Macintosh and on PCs under MSDOS.
  402.  
  403.         ftp: ftp.inria.fr, directory lang/caml-light
  404.  
  405.  
  406. Clean:          The Concurrent Clean system is a programming
  407.         environment for the functional language Concurrent
  408.         Clean, developed at the University of Nijmegen,
  409.         The Netherlands. The system is one of the fastest
  410.         implementations of functional languages available
  411.         at the moment. Its I/O libraries make it possible
  412.         to do modern, yet purely functional I/O (including
  413.         windows, menus, dialogs etc.) in Concurrent Clean.
  414.         With the Concurrent Clean system it is possible to
  415.         develop real-life applications in a purely functional
  416.         language.  Particular features include:
  417.  
  418.           o lazy and purely functional
  419.           o strongly typed - based on Milner/Mycroft scheme
  420.           o module structure
  421.           o modern I/O
  422.           o programmer-influenced evaluation order by
  423.                     annotations
  424.  
  425.         ftp: host ftp.cs.kun.nl,  directory pub/Clean
  426.         available for: Mac, Sun 3, Sun 4
  427.  
  428.         There is a book describing Concurrent Clean and
  429.         its implementation on sequential and parallel
  430.         architectures:
  431.  
  432.         "Functional Programming and Parallel Graph Rewriting",
  433.         Rinus Plasmeijer and Marko van Eekelen,
  434.         Addison Wesley, International Computer Science Series.
  435.         Hardcover, 571 pages.
  436.         ISBN 0-201-41663-8
  437.  
  438.  
  439. Erlang:        Concurrent functional programming language for
  440.         large industrial real-time systems. Untyped.
  441.         Pattern matching syntax.  Recursion equations.
  442.         Explicit concurrency, asynchronous message
  443.         passing.  Relatively free from side effects.
  444.         Transparent cross-platform distribution.  Primitives
  445.         for detecting run-time errors.  Real-time GC.
  446.         Modules.  Dynamic code replacement (change code
  447.         in running real-time system, without stopping
  448.         system).  Foreign language interface.
  449.  
  450.         Availability: Free version (subject to non-commercial
  451.         license) with no support.  Commercial versions
  452.         with support are available (Erlang Systems AB).
  453.  
  454.         Info: erlang@erix.ericsson.se
  455.         FTP Info: euagate.eua.ericsson.se:/pub/eua/erlang/info
  456.  
  457.         See also:
  458.         "Concurrent Programming in Erlang", J. Armstrong,
  459.         M. Williams & R. Virding, Prentice Hall, 1993.
  460.         ISBN 13-285792-8.
  461.  
  462.  
  463. FP:             Backus' side-effect free, combinator style language
  464.         described by:
  465.  
  466.         "Can Programming be Liberated from the Von
  467.         Neumann Style?", J. Backus, Communications of the
  468.         ACM, 21, 8, pp.613-641, 1978.
  469.  
  470.         There are (at least) three easily accessible
  471.         implementations of FP.  Two of these are available
  472.         from any site that archives comp.sources.unix.
  473.         For example, at gatekeeper.dec.com you will find
  474.         these in:
  475.  
  476.          pub/usenet/comp.sources.unix/volume13/funcproglang
  477.          pub/usenet/comp.sources.unix/volume20/fpc
  478.  
  479.         The first of these is an interpreter, the second a
  480.         translator from FP to C.
  481.  
  482.         The third implementation, IFP is described separately
  483.         below.
  484.  
  485.  
  486. Gofer:        The Gofer system provides an interpreter for a small
  487.         language based closely on the current version of
  488.         the Haskell report.  In particular, Gofer supports
  489.         lazy evaluation, higher-order functions, polymorphic
  490.         typing, pattern-matching, support for overloading, etc.
  491.  
  492.         ftp: nebula.cs.yale.edu,  directory: pub/haskell/gofer
  493.  
  494.         Gofer runs on a wide range of machines including
  495.         PCs, Ataris, Amigas, etc.  as well as larger
  496.         Unix-based systems.  A version for the Apple
  497.         Macintosh has been produced and is available by
  498.         anonymous ftp from ftp.dcs.glasgow.ac.uk in a
  499.         subdirectory of pub/haskell/gofer.
  500.  
  501.         Please note the spelling, derived from the notion
  502.         that functional languages are GOod For Equational
  503.         Reasoning.  This is not to be confused with `Gopher',
  504.         the widely used Internet distributed information
  505.         delivery system!
  506.  
  507.  
  508. Haskell:    In the mid-1980s, there was no "standard" non-strict,
  509.         purely-functional programming language.  A
  510.         language-design committee was set up in 1987, and
  511.         the Haskell language is the result.
  512.  
  513.         The Haskell committee released its report on 1
  514.         April 1990. A revised "Version 1.2" appeared in
  515.         SIGPLAN Notices 27(5) (May 1992), along with a
  516.         tutorial on Haskell by Hudak and Fasel.
  517.  
  518.         At the time of writing, there are three different
  519.         Haskell systems available, developed by groups at
  520.         Chalmers, Glasgow and Yale (several others are
  521.         being developed).  These systems are available
  522.         from the following sites:
  523.            Chalmers    ftp.cs.chalmers.se
  524.            Glasgow    ftp.dcs.glasgow.ac.uk
  525.            Yale        nebula.cs.yale.edu
  526.         At each site, all of the files related to Haskell
  527.         are stored in the directory pub/haskell.  Specialized
  528.         material, or recent releases of these systems may
  529.         sometimes only be available from the systems ``home
  530.         site''.  Machine-readable versions of the Haskell
  531.         report, tutorials, and some programs are also
  532.         available at these sites.
  533.  
  534.         A description of the current status of the various
  535.         Haskell implementations is occasionally posted on
  536.         the Haskell mailing list, and sometimes on
  537.         comp.lang.functional.  Copies of this document are
  538.         often kept on the Haskell sites mentioned above.
  539.         For example, this information may be found in
  540.         pub/haskell/papers/Haskell.status at the Yale site
  541.         (nebula.cs.yale.edu).
  542.  
  543.  
  544. Hope:        A small polymorphically-typed functional language.
  545.         First language to use call-by-pattern.    Hope was
  546.         originally strict, but there are versions with lazy
  547.         lists, or with lazy constructors but strict functions.
  548.         A fully lazy interpreter is available from:
  549.  
  550.         ftp: santos.doc.ic.ac.uk:/pub/papers/R.Paterson/hope.tar.Z
  551.  
  552.  
  553. Id:             The core of Id is a non-strict functional language
  554.         with implicit parallelism.  It has the usual features
  555.         of many modern functional languages, including a
  556.         Hindley/Milner type inference system, algebraic
  557.         types and definitions with clauses and pattern
  558.         matching, and list comprehensions.
  559.  
  560.  
  561. IFP:            The Illinois FP system is a modified version of
  562.         Backus' FP with a more Algol-like syntax and
  563.         structure.  Described in:
  564.  
  565.         "The Illinois Functional Programming Interpreter",
  566.         Arch D. Robison, Proceedings of the SIGPLAN '87
  567.         Symposium on Interpreters and Interpretive Techniques,
  568.         SIGPLAN notices vol 22, no 7, July 1987.
  569.  
  570.         ftp: a.cs.uiuc.edu.    versions for Unix and MSDOS
  571.  
  572.  
  573. J:              J was designed and developed by Ken Iverson and
  574.         Roger Hui.  It is similar to the language APL,
  575.         departing from APL in using using the ASCII alphabet
  576.         exclusively, but employing a spelling scheme that
  577.         retains the advantages of the special alphabet
  578.         required by APL. It has added features and control
  579.         structures that extend its power beyond standard
  580.         APL.  Although it can be used as a conventional
  581.         procedural programming language, it can also be
  582.         used as a pure functional programming language.
  583.  
  584.         ftp: watserv1.waterloo.edu.
  585.  
  586.  
  587. Miranda(TM):    Miranda was designed in 1985-6 by David Turner with
  588.         the aim of providing a standard non-strict purely
  589.         functional language.  It is described in D. A.
  590.         Turner ``Miranda: A Non-Strict Functional Language
  591.         with Polymorphic Types'', Proceedings FPLCA, Nancy,
  592.         France, September 1985 (Springer LNCS vol 201, pp
  593.         1-16) and D. A. Turner ``An Overview of  Miranda'',
  594.         SIGPLAN Notices, vol 21, no 12, pp 158-166 (December
  595.         1986).
  596.  
  597.         Miranda was the first widely disseminated language
  598.         with non-strict semantics and polymorphic strong
  599.         typing, and is now running at over 600 sites,
  600.         including 250 universities.  It is widely used for
  601.         teaching, often in conjunction with "Introduction
  602.         to Functional Programming", by Bird & Wadler, which
  603.         uses a notation closely based on Miranda.
  604.  
  605.         It has also had a strong influence on the subsequent
  606.         development of the field and provided one of the
  607.         main inputs for the design of the later language
  608.         Haskell (see separate entry).
  609.  
  610.         Miranda was awarded a medal for technical achievement
  611.         by the British Computer Society (BCS Awards, 1990).
  612.  
  613.         The Miranda system is a commercial product of
  614.         Research Software Limited.  Miranda release two
  615.         (the current version) supports unbounded precision
  616.         integers and has a module system with provision
  617.         for parameterized modules and a built in "make"
  618.         facility.  The compiler works in conjunction with
  619.         a screen editor and programs are automatically
  620.         recompiled after edits.  There is an online reference
  621.         manual.
  622.  
  623.         Note that the word "Miranda" is a trademark (TM)
  624.         of Research Software Limited.  There are no public
  625.         domain versions of Miranda.
  626.  
  627.         Further information about Miranda may be obtained
  628.         from
  629.                    mira-request@ukc.ac.uk
  630.                 or
  631.                    Research Software Ltd
  632.                    23 St Augustines Road
  633.                    Canterbury CT1 1XP       phone: (+44) 227 471844
  634.                    ENGLAND                  fax:   (+44) 227 454458
  635.  
  636.  
  637. ML:             ML (which stands for Meta-Language) is a family of
  638.         advanced programming languages with [usually]
  639.         functional control structures, strict semantics,
  640.         a strict polymorphic type system, and parameterized
  641.         modules.  It includes Standard ML, Lazy ML, CAML,
  642.         CAML Light, and various research languages.
  643.         Implementations are available on many platforms,
  644.         including PCs, mainframes, most models of workstation,
  645.         multi-processors and supercomputers.  ML has many
  646.         thousands of users, is taught at many universities
  647.         (and is the first programming language taught at
  648.         some).
  649.  
  650.         There is a moderated usenet newsgroup, comp.lang.ml,
  651.         for the discussion of topics related to ML.  A list
  652.         of frequently asked questions for ML is posted to
  653.         this group each month by the moderator, Greg
  654.         Morrisett.  The first paragraph above is taken
  655.         directly from this FAQ.
  656.  
  657.         There are several implementations of ML including
  658.         Poly/ML, SML/NJ, PoplogML, Edinburgh, ANU ML, Micro
  659.         ML, sml2c, Caml Light, and the ML kit.  Further
  660.         details for each of these systems are included in
  661.         the comp.lang.ml FAQ.
  662.  
  663.         The Standard ML language is formally defined by:
  664.  
  665.         "The Definition of Standard ML", Robin Milner, Mads
  666.         Tofte and Robert Harper, MIT, 1990.  ISBN:
  667.         0-262-63132-6
  668.  
  669.         "Commentary on Standard ML", Robin Milner and Mads
  670.         Tofte, MIT, 1991 ISBN: 0-262-63137-7
  671.  
  672.         There are a number of texts describing programming
  673.         in ML.  Again, full details are given in the
  674.         comp.lang.ml FAQ.
  675.  
  676.  
  677. NESL:        NESL is a fine-grained, functional, nested
  678.         data-parallel language.  The current implementation
  679.         runs on workstations, the Connection Machines CM2
  680.         and CM5, the Cray Y-MP and the MasPar MP2.
  681.  
  682.         NESL is loosely based on ML.  It includes a built-in
  683.         parallel data-type, sequences, and parallel operations
  684.         on sequences (the element type of a sequence can
  685.         be any type, not just scalars).  It is based on
  686.         eager evaluation, and supports polymorphism, type
  687.         inference and a limited use of higher-order functions.
  688.         Currently it does not have support for modules and
  689.         its datatype definition is limited.  Except for
  690.         I/O and some system utilities it is purely functional
  691.         (it does not support reference cells or call/cc).
  692.         The compiler is based on delayed compilation and
  693.         compiles separate code for each type a function is
  694.         used with (compiled code is monomorphic).  The
  695.         implementation therefore requires no type bits,
  696.         and can do some important data-layout optimizations
  697.         (e.g. double-precision floats don't need to be
  698.         boxed, and nested sequences can be laid out
  699.         efficiently across multiple processors).  For
  700.         several small benchmark applications on irregular
  701.         and/or dynamic data (e.g graphs and sparse matrices)
  702.         it generates code comparable in efficiency to
  703.         machine-specific low-level code (e.g. Fortran or C).
  704.  
  705.         The system is available via anonymous FTP to
  706.         nesl.scandal.cs.cmu.edu (currently 128.2.222.128),
  707.         in the file code/nesl/nesl.tar.Z (1.2Mbytes).
  708.         There is a README file in the nesl directory that
  709.         contains further information.  You can be added to
  710.         the NESL mailing list by sending e-mail to
  711.         nesl-request@cs.cmu.edu.  The examples and
  712.         documentation are also available separately.
  713.  
  714.  
  715. OPAL:        The language OPAL has been designed as a testbed
  716.         for the development of functional programs. Opal
  717.         molds concepts from Algebraic Specification and
  718.         Functional Programming, which shall favor the
  719.         (formal) development of (large) production-quality
  720.         software that is written in a purely functional
  721.         style.
  722.  
  723.         The core of OPAL is a strongly typed, higher-order,
  724.         strict applicative language which belongs to the
  725.         tradition of HOPE and ML. The algebraic flavour of
  726.         OPAL shows up in the syntactical appearance and
  727.         the preference of parameterization to polymorphism.
  728.  
  729.         OPAL is used for research on the highly optimizing
  730.         compilation of applicative languages. This has
  731.         resulted in a compiler which produces very efficient
  732.         code. The OPAL compiler itself is entirely written
  733.         in OPAL.
  734.  
  735.         Papers describing OPAL, and the OPAL compilation
  736.         system itself, are available by anonymous ftp from:
  737.  
  738.             ftp.cs.tu-berlin.de
  739.  
  740.         This includes an overview of OPAL in the file:
  741.  
  742.             pub/local/uebb/papers/DesignImplOpal.ps.gz
  743.  
  744.         A language tutorial:
  745.  
  746.             pub/local/uebb/papers/TutorialOpal.ps.gz
  747.  
  748.         The compilation system is in the pub/local/uebb/ocs
  749.         directory.  Installation is straightforward and
  750.         has been successfully performed for SPARCs,
  751.         DECstations, NeXTs, and PCs running LINUX.
  752.  
  753.  
  754. Scheme:        Scheme is a dialect of Lisp that stresses conceptual
  755.         elegance and simplicity. It is specified in R4RS
  756.         and IEEE standard P1178. (See question [1-7] for
  757.         details on standards for Scheme.) Scheme is much
  758.         smaller than Common Lisp; the specification is
  759.         about 50 pages.
  760.  
  761.         Scheme is often used in computer science curricula
  762.         and programming language research, due to its
  763.         ability to represent many programming abstractions
  764.         with its simple primitives.
  765.  
  766.         There is an unmoderated usenet newsgroup,
  767.         comp.lang.scheme for the discussion of topics
  768.         related to Scheme, and a list of frequently asked
  769.         questions for Scheme is posted to the group each
  770.         month by Mark Kantrowitz.  The FAQ list is also
  771.         available online from several sources; for example,
  772.         it can be obtained by anonymous ftp from ftp.think.com
  773.         in the file /public/think/lisp/scheme-faq.text.
  774.  
  775.         There are many books and papers dealing with Scheme.
  776.         Please consult the comp.lang.scheme frequently
  777.         asked questions list for further details.
  778.  
  779.         The Scheme Repository, maintained by Ozan S. Yigit,
  780.         is accessible by anonymous ftp at nexus.yorku.ca
  781.         [130.63.9.66] in the directory pub/scheme/, and
  782.         contains a Scheme bibliography, copies of the R4RS
  783.         report, IEEE P1178 specification and other papers,
  784.         sample Scheme code for a variety of purposes,
  785.         several utilities, and some implementations.  The
  786.         repository is mirrored in INRIA, courtesy of
  787.         Christian Queinnec [Ecole Polytechnique and
  788.         INRIA-Rocquencourt], ftp.inria.fr:lang/Scheme.
  789.  
  790.  
  791. Sisal:          Sisal (Streams and Iteration in a Single Assignment
  792.         Language) is a functional language designed with
  793.         several goals in mind:  to support clear, efficient
  794.         expression of scientific programs; to free application
  795.         programmers from details irrelevant to their
  796.         endeavors; and, to allow automatic detection and
  797.         exploitation of the parallelism expressed in source
  798.         programs.
  799.  
  800.         Sisal syntax is modern and easy to read; Sisal code
  801.         looks similar to Pascal, Modula, or Ada, with modern
  802.         constructs and long identifiers. The major difference
  803.         between Sisal and more conventional languages is
  804.         that it does not express explicit program control flow.
  805.  
  806.         Sisal semantics are mathematically sound. Programs
  807.         consist of function definitions and invocations.
  808.         Functions have no side effects, taking as inputs
  809.         only explicitly passed arguments, and producing
  810.         only explicitly returned results. There is no
  811.         concept of state in Sisal.  Identifiers are used,
  812.         rather than variables, to denote values, rather
  813.         than memory locations.
  814.  
  815.         The Sisal language currently exists for several
  816.         shared memory and vector systems that run Berkeley
  817.         Unix(tm), including the Sequent Balance and Symmetry,
  818.         the Alliant, the Cray X/MP and Y/MP, Cray 2, and
  819.         a few other less well-known ones.  Sisal is available
  820.         on sequential machines such as Sparc, RS/6000, and
  821.         HP.  Sisal also runs under MS-DOS and Macintosh
  822.         Unix (A/UX). It's been shown to be fairly easy to
  823.         port the entire language system to new machines.
  824.  
  825.         ftp: sisal.llnl.gov (128.115.19.65)
  826.  
  827.         For more information, pleases send an email request to:
  828.             sisal-info-request@sisal.llnl.gov
  829.  
  830.         See also: "Retire FORTRAN? A debate rekindled",
  831.         David Cann, CACM, 35(8), pp.81-89, Aug 1992
  832.  
  833.  
  834. ---------------------------------------------------------------------------
  835. 4) OTHER RESOURCES:
  836.  
  837. 4.1) Bibliographies:
  838.  
  839.   o  Mike Joy maintains a bibliography on Functional Languages,
  840.      in refer(1) format.  It is available by anonymous ftp from:
  841.      ftp.dcs.warwick.ac.uk in the files:
  842.  
  843.        pub/biblio/functional.README pub/biblio/functional.refer.Z
  844.  
  845.   o  Tony Davie maintains a bibliography of over 2,600 papers,
  846.      articles and books on functional programming and functional
  847.      systems.  It can be obtained by anonymous ftp from
  848.      tamdhu.dcs.st-and.ac.uk in the directory pub/staple, either
  849.      as a hypercard stack in pubs.sit.Hqx, or as a (compressed)
  850.      text file in pubs.txt.Z.
  851.  
  852.   o  Wolfgang Schreiner has compiled an annotated bibliography
  853.      on parallel functional programming that lists more than 350
  854.      publications mostly including their *full abstracts*.
  855.  
  856.      You can retrieve the bibliography by anonymous ftp from
  857.      ftp.risc.uni-linz.ac.at (193.170.36.100) in
  858.      pub/reports/parlab/pfpbib2.dvi.Z (or pfpbib2.ps.Z).
  859.  
  860.   o  State in Functional Programming: An Annotated Bibliography,
  861.      edited by P. Hudak and D. Rabin, is available by anonymous
  862.      ftp from nebula.cs.yale.edu in the files:
  863.  
  864.        pub/yale-fp/papers/state-bib.<format>.<compression> where
  865.        <format>      ::= ps | dvi
  866.          <compression> :: = z | Z
  867.  
  868.  
  869. 4.2) Translators:
  870.  
  871.   o  Miranda(TM) to LML and Miranda(TM) to Haskell translators
  872.      written by Denis Howe are available by anonymous ftp from
  873.      wombat.doc.ic.ac.uk (146.169.22.42) in directory pub, files
  874.      mira2hs-1.05 and mira2lml-0.00
  875.  
  876.  
  877. 4.3) Online services:
  878.  
  879.   o If you have wais, the source is listed below, or it can be
  880.     easily obtained from the directory-of-servers. If you don't
  881.     have wais, subscribe to comp.infosystems.wais and find someone
  882.     to ask.
  883.  
  884.     (:source
  885.        :version  3 :ip-address "137.219.17.4" :ip-name
  886.        "coral.cs.jcu.edu.au" :tcp-port 8000 :database-name
  887.        "Func-Prog-Abstracts" :cost 0.00 :cost-unit :free :maintainer
  888.        "farrell@coral.cs.jcu.edu.au" :description "Server created
  889.        with WAIS release 8 b3.1
  890.      on Apr 22 19:06:25 1992 by farrell@coral.cs.jcu.edu.au
  891.  
  892.      Keywords: help intro introduction info information computer
  893.     science technical reports functional programming
  894.  
  895.      This is a small collection of computer science technical
  896.      reports, abstracts and papers gathered from ftp sites etc.
  897.      all over the world. Due to space considerations, I am limiting
  898.      it to functional programming, my area of interest, and papers
  899.      produced by the department (which may or may not be related
  900.      to functional programming).
  901.  
  902.      Comments, problems etc to the maintainer above.  " )
  903.  
  904.  
  905.   o The Free On-Line Dictionary of Computing is available by Gopher
  906.     and FTP from wombat.doc.ic.ac.uk.  It is not restricted to
  907.     functional programming but does include quite a few FP terms.
  908.  
  909.  
  910.   o A collection of online resources for programming language
  911.     research is available on the World-Wide Web:
  912.  
  913.     http://www.cs.cmu.edu:8001
  914.             /afs/cs.cmu.edu/user/mleone/web/language-research.html
  915.  
  916.     (For more information on the World-Wide Web, see the WWW FAQ,
  917.     available by anonymous FTP from rtfm.mit.edu as
  918.     /pub/usenet/news.answers/www/faq.)
  919.  
  920.  
  921. ---------------------------------------------------------------------------
  922. 5) CREDITS AND DISCLAIMERS:
  923.  
  924. The information in this article has been taken from public sources,
  925. mostly from articles posted on comp.lang.functional during the past
  926. eighteen months.  This FAQ includes contributions from many different
  927. people -- because of the way that the FAQ was compiled, I regret
  928. to say that I do not have a complete list of contributors.
  929.  
  930. The aim of this FAQ is to provide information about functional
  931. languages and to reflect widely held views in the functional
  932. programming community.  Any opinions expressed in this message are
  933. those of the individual contributors, and may not be representative
  934. either of my own personal views, or of others in the community.
  935.  
  936. It is very likely that this FAQ contains some significant errors
  937. and omissions: There are no guarantees for the accuracy of the
  938. information provided here.  Of course, your corrections and
  939. contributions are encouraged!
  940.  
  941.  
  942. ---------------------------------------------------------------------------
  943.  
  944.